/* MUSS NEU KONFIGURIERT WERDEN  */



/*
   ============================================================================
   Programmname: logik_bridges.c
   Autor       : Sebastian Spiller
                 HHBK Gruppe A
   Datum       : 07.05.2011
   Projekt     : C-Spiele
   Version     : 1.0
   Aenderung   : -

   Programmschnittstelle: int main(void)
                          Das Programm gibt den Wert 0 oder 1 zurueck.
                          Es werden keine Argumente erwartet.

   Hier wird die Spiellogik von Bridges implementiert.

   ============================================================================
*/


/*
============================================================================
Präprozessoranweisungen
============================================================================
*/
#include "util.h"


/**
 * Erzeugt Brett und Eingabe
 * @param  void
 * @return int 0 / 1, 0 fuer korrekten Ablauf
 */
int renderCheckers(void)
{
    render(ID_CHECKERS);

    return 0;
} // function


/**
* Ueberprueft ob noch ein weiterer Zug moeglich ist
* @param  int aiStart[1][1] Token-Koordinaten [Row, Column]
* @param  int iPlayer       SpielerID des Spielers, der als naechstes am Zug ist
* @return int TRUE / FALSE  Gibt an, ob noch ein Zug moeglich ist
*/
int checkMovePossible(int aiStart[2], int iPlayer, int iShowErrors)
{
    int iReturn      = FALSE;
    int iRow         = 0;
    int iCol         = 0;
    int aiMove[2][2];

    aiMove[START][ROW] = (int)aiStart[0];
    aiMove[START][COL] = (int)aiStart[1];

    for (iRow = 0; iRow <= NO_OF_ROWS; iRow++)
    {
        for (iCol = 0; iCol <= NO_OF_COLS; iCol++)
        {
            aiMove[TARGET][ROW] = iRow;
            aiMove[TARGET][COL] = iCol;

            // Ist noch ein Zug moeglich? Bedingung funktioniert als Flag
            if ( TRUE == checkMove(aiMove, iPlayer, FALSE) )
                iReturn = TRUE;
        } // for
    } // for
    return iReturn;

} // function



/**
* Ueberprueft, ob das Spiel von einem der beiden Spieler gewonnen wurde.
* @param  int iPlayer SpielerID des Spielers, der als naechstes am Zug ist
* @return int             0: noch kein Spieler hat gewonnen ,
*                         1: Spieler 1, resp.
*                         2: Spieler 2 hat gewonnen
*                         3: Das Spiel endet untentschieden
*/
int checkGameFinished(int iPlayer)
{
    int iReturn       = TRUE;
    int iRow          = 0;
    int iCol          = 0;
    int aiStart[2];

    for (iRow = 0; iRow <= NO_OF_ROWS; iRow++)
    {
        for (iCol = 0; iCol <= NO_OF_COLS; iCol++)
        {
            if (0 != aiBoard[iRow][iCol])
            {
                aiStart[0] = iRow;
                aiStart[1] = iCol;

                // Ist noch ein gegnerischer Stein da? ok wg irow ungleich 0 geprueft s o
                if (0 != aiBoard[iRow][iCol] % iPlayer)
                    iReturn = FALSE;
                // Spielzug moeglich?
                else if (TRUE == checkMovePossible(aiStart, iPlayer))
                    iReturn = FALSE;
            } // if
        } // for
    } // for

    return iReturn;
} // function



/**
 * Ueberprueft ob der Zug legal ist
 * @param  void
 * @param  int aiMove[2][2] Zug mit Start und Zielkoordinaten [Start/Ziel][Row/Column]
 * @param  int iPlayer      Spieler, der am Zug ist
 * @param  int iShowErrors  Fehlerausgabe aktivieren
 * @return int TRUE / FALSE Ist Zug moeglich?
 */
int checkMove(int aiMove[2][2], int iPlayer, int iShowErrors)
{
    int i        = 0; // Zaehlvariable
    int iCheck   = TRUE;
    int iStart   = 0;
    int iTarget  = 0;
    int iMoveCol = 0; // Differenz aus Start- und Endkoordinaten in Spaltenrichtung
    int iMoveRow = 0; // analog

    int iStartRow  = aiMove[START][ROW];
    int iStartCol  = aiMove[START][COL];
    int iTargetRow = aiMove[TARGET][ROW];
    int iTargetCol = aiMove[TARGET][COL];

    iStart  = aiBoard[aiMove[START][ROW]][aiMove[START][COL]];
    iTarget = aiBoard[iTargetRow][iTargetCol];

    iMoveCol = aiMove[TARGET][COL] - aiMove[START][COL];
    iMoveRow = aiMove[TARGET][ROW] - aiMove[START][ROW];


// Regeln pruefen (Aufbau fuer Performance: Sofortiger Abbruch bei Fehler
    if (
          // Start ausserhalb Spielfeld
          ( (aiMove[START][ROW] < 0) || (aiMove[START][ROW] >= NO_OF_ROWS) )
       || ( (aiMove[START][COL] < 0) || (aiMove[START][COL] >= NO_OF_COLS) )

          // Start ausserhalb Spielfeld
       || ( (aiMove[TARGET][ROW] < 0) || (aiMove[TARGET][ROW] >= NO_OF_ROWS) )
       || ( (aiMove[TARGET][COL] < 0) || (aiMove[TARGET][COL] >= NO_OF_COLS) )

          // Eingabefeld == Ausgabefeld
       || (  ( aiMove[START][ROW] ==  aiMove[TARGET][ROW])
          && ( aiMove[START][COL] ==  aiMove[TARGET][COL]) )

          // ZielFeld besetzt
       || ( 0 != aiBoard[aiMove[TARGET][ROW]][aiMove[TARGET][COL]] )

       )
    {
        iCheck = FALSE;
    } // if

    return iCheck;
} // function



/**
* Initialisiere Spielbrett-Array mit Figurenpositionen
* @param  void
* @return TRUE / FALSE    Eingabe erfolgreich
*/
int initCheckers(void)
{
    int iRow      = 0;
    int iCol      = 0;

    for (iRow = 0; iRow < NO_OF_ROWS; iRow++)
    {
        for (iCol = 0; iCol < NO_OF_COLS; iCol++)
        {
            aiBoard[iRow][iCol] = 0;

            if (0 == ((iRow + iCol) % 2))
                aiBoard[iRow][iCol] = 1;
            else if (1 == ((iRow + iCol) % 2)) 
                aiBoard[iRow][iCol] = 2;
        } // for
    } // for
} // function



/**
* Fuehre Spielzug aus
* @param void
* @param int aiMove[2][2] SpielZug
*/
void moveToken(int aiMove[2][2])
{
    int iToken  = 0;
    int iPlayer = 1;

    iToken = iPlayer;

    //iToken = aiBoard[aiMove[START][ROW]][aiMove[START][COL]];
    //aiBoard[aiMove[START][ROW]][aiMove[START][COL]] = 0;
    aiBoard[aiMove[TARGET][ROW]][aiMove[TARGET][COL]] = iToken;

} // function
